home *** CD-ROM | disk | FTP | other *** search
/ Nebula 1 / Nebula One.iso / Graphics / Viewers / VideoStreamV1.0 / Source / mpegDecodeSrc / util.h < prev    next >
Encoding:
C/C++ Source or Header  |  1995-06-12  |  18.2 KB  |  313 lines
  1. /*
  2.  * Copyright (c) 1992 The Regents of the University of California.
  3.  * All rights reserved.
  4.  * 
  5.  * Permission to use, copy, modify, and distribute this software and its
  6.  * documentation for any purpose, without fee, and without written agreement is
  7.  * hereby granted, provided that the above copyright notice and the following
  8.  * two paragraphs appear in all copies of this software.
  9.  * 
  10.  * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
  11.  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
  12.  * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
  13.  * CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  14.  * 
  15.  * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
  16.  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  17.  * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  18.  * ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO
  19.  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  20.  */
  21. /* Status codes for bit stream i/o operations. */
  22.  
  23. #define NO_VID_STREAM -1
  24. #define UNDERFLOW -2
  25. #define OK 1
  26.  
  27. /* Size increment of extension data buffers. */
  28.  
  29. #define EXT_BUF_SIZE 1024
  30.  
  31. /* External declarations for bitstream i/o operations. */
  32. extern unsigned int bitMask[];
  33. extern unsigned int nBitMask[];
  34. extern unsigned int rBitMask[];
  35. extern unsigned int bitTest[];
  36. extern int next_bits();
  37. extern char *get_ext_data();
  38. extern int next_start_code();
  39. extern char *get_extra_bit_info();
  40.  
  41. /* External declarations of bitstream global variables. */
  42. extern unsigned int curBits;
  43. extern int bitOffset;
  44. extern int bufLength;
  45. extern unsigned int *bitBuffer;
  46.  
  47. #ifdef NO_SANITY_CHECKS
  48. #define get_bits1(result)                                                 \
  49. {                                                                         \
  50.   if (bitOffset < 31) {                                                   \
  51.     *(result) = ((curBits & bitTest[bitOffset]) != 0);                    \
  52.     bitOffset++;                                                          \
  53.   }                                                                       \
  54.   else {                                                                  \
  55.     *(result) = (curBits & 0x00000001);                                   \
  56.     bitOffset = 0;                                                        \
  57.     bitBuffer++;                                                          \
  58.     curBits = *bitBuffer;                                                 \
  59.     bufLength--;                                                          \
  60.   }                                                                       \
  61. }
  62.  
  63. #define get_bits2(result)                                                 \
  64. {                                                                         \
  65.   if (bitOffset < 30) {                                                   \
  66.     *(result) = ((curBits & bitMask[bitOffset]) >>                        \
  67.            (30-bitOffset));                                           \
  68.     bitOffset += 2;                                                       \
  69.   }                                                                       \
  70.   else if (bitOffset == 30) {                                             \
  71.     *(result) = (curBits & 0x00000003);                                   \
  72.     bitOffset = 0;                                                        \
  73.     bitBuffer++;                                                          \
  74.     curBits = *bitBuffer;                                                 \
  75.     bufLength--;                                                          \
  76.   }                                                                       \
  77.   else {                                                                  \
  78.     *(result) = (((curBits & 0x01) << 1) |                                \
  79.            ((*(bitBuffer+1) & 0x80000000) != 0));                     \
  80.     bitOffset = 1;                                                        \
  81.     bitBuffer++;                                                          \
  82.     curBits = *bitBuffer;                                                 \
  83.     bufLength--;                                                          \
  84.   }                                                                       \
  85. }
  86.  
  87. #define get_bitsX(num, thresh, result)                                    \
  88. {                                                                         \
  89.   int OFFnum = (bitOffset - thresh);                                      \
  90.                                                                           \
  91.                                                                           \
  92.   if (OFFnum < 0) {                                                       \
  93.     *(result) = ((curBits & bitMask[bitOffset]) >> (-OFFnum));            \
  94.     bitOffset += num;                                                     \
  95.   } else if (OFFnum == 0) {                                               \
  96.     *(result) = (curBits & bitMask[bitOffset]) << OFFnum;                 \
  97.     bitBuffer++;                                                          \
  98.     curBits = *bitBuffer;                                                 \
  99.     bufLength--;                                                          \
  100.     bitOffset = 0;                                                        \
  101.   } else {                                                                \
  102.     *(result) = (((curBits & bitMask[bitOffset]) << OFFnum) |             \
  103.              ((*(bitBuffer+1) & (nBitMask[OFFnum])) >> (32-OFFnum))); \
  104.     bitBuffer++;                                                          \
  105.     curBits = *bitBuffer;                                                 \
  106.     bufLength--;                                                          \
  107.     bitOffset = OFFnum;                                                   \
  108.   }                                                                       \
  109. }
  110. #else
  111.  
  112. #define get_bits1(result)                                                 \
  113. {                                                                         \
  114.                                                                           \
  115.   /* Check for underflow. */                                              \
  116.                                                                           \
  117.   if (bufLength < 2) {                                                    \
  118.     correct_underflow();                                                  \
  119.   }                                                                       \
  120.                                                                           \
  121.   if (bitOffset < 31) {                                                   \
  122.     *(result) = ((curBits & bitTest[bitOffset]) != 0);                    \
  123.     bitOffset++;                                                          \
  124.   }                                                                       \
  125.   else {                                                                  \
  126.     *(result) = (curBits & 0x00000001);                                   \
  127.     bitOffset = 0;                                                        \
  128.     bitBuffer++;                                                          \
  129.     curBits = *bitBuffer;                                                 \
  130.     bufLength--;                                                          \
  131.   }                                                                       \
  132. }
  133.  
  134. #define get_bits2(result)                                                 \
  135. {                                                                         \
  136.                                                                           \
  137.   /* Check for underflow. */                                              \
  138.                                                                           \
  139.   if (bufLength < 2) {                                                    \
  140.     correct_underflow();                                                  \
  141.   }                                                                       \
  142.                                                                           \
  143.   if (bitOffset < 30) {                                                   \
  144.     *(result) = ((curBits & bitMask[bitOffset]) >>                        \
  145.            (30-bitOffset));                                           \
  146.     bitOffset += 2;                                                       \
  147.   }                                                                       \
  148.   else if (bitOffset == 30) {                                             \
  149.     *(result) = (curBits & 0x00000003);                                   \
  150.     bitOffset = 0;                                                        \
  151.     bitBuffer++;                                                          \
  152.     curBits = *bitBuffer;                                                 \
  153.     bufLength--;                                                          \
  154.   }                                                                       \
  155.   else {                                                                  \
  156.     *(result) = (((curBits & 0x01) << 1) |                                \
  157.            ((*(bitBuffer+1) & 0x80000000) != 0));                     \
  158.     bitOffset = 1;                                                        \
  159.     bitBuffer++;                                                          \
  160.     curBits = *bitBuffer;                                                 \
  161.     bufLength--;                                                          \
  162.   }                                                                       \
  163. }
  164.  
  165. #define get_bitsX(num, thresh, result)                                    \
  166. {                                                                         \
  167.   int OFFnum = (bitOffset - thresh);                                      \
  168.                                                                           \
  169.   /* Check for underflow. */                                              \
  170.                                                                           \
  171.   if (bufLength < 2) {                                                    \
  172.     correct_underflow();                                                  \
  173.   }                                                                       \
  174.                                                                           \
  175.   if (OFFnum < 0) {                                                       \
  176.     *(result) = ((curBits & bitMask[bitOffset]) >> (-OFFnum));            \
  177.     bitOffset += num;                                                     \
  178.   } else if (OFFnum == 0) {                                               \
  179.     *(result) = (curBits & bitMask[bitOffset]) << OFFnum;                 \
  180.     bitBuffer++;                                                          \
  181.     curBits = *bitBuffer;                                                 \
  182.     bufLength--;                                                          \
  183.     bitOffset = 0;                                                        \
  184.   } else {                                                                \
  185.     *(result) = (((curBits & bitMask[bitOffset]) << OFFnum) |             \
  186.              ((*(bitBuffer+1) & (nBitMask[OFFnum])) >> (32-OFFnum))); \
  187.     bitBuffer++;                                                          \
  188.     curBits = *bitBuffer;                                                 \
  189.     bufLength--;                                                          \
  190.     bitOffset = OFFnum;                                                   \
  191.   }                                                                       \
  192. }
  193. #endif
  194.  
  195. #define get_bits3(result) get_bitsX(3, 29, result)
  196. #define get_bits4(result) get_bitsX(4, 28, result)
  197. #define get_bits5(result) get_bitsX(5, 27, result)
  198. #define get_bits6(result) get_bitsX(6, 26, result)
  199. #define get_bits7(result) get_bitsX(7, 25, result)
  200. #define get_bits8(result) get_bitsX(8, 24, result)
  201. #define get_bits9(result) get_bitsX(9, 23, result)
  202. #define get_bits10(result) get_bitsX(10, 22, result)
  203. #define get_bits11(result) get_bitsX(11, 21, result)
  204. #define get_bits12(result) get_bitsX(12, 20, result)
  205. #define get_bits16(result) get_bitsX(16, 16, result)
  206. #define get_bits18(result) get_bitsX(18, 14, result)
  207. #define get_bits32(result) get_bitsX(32, 0, result)
  208.  
  209. #define get_bitsn(num, result) get_bitsX((num),(32-(num)),result)
  210.  
  211. #ifdef NO_SANITY_CHECKS
  212. #define show_bitsX(num, thresh, result)                                    \
  213. {                                                                          \
  214.   int OFFnum = (bitOffset - thresh);                                       \
  215.                                                                           \
  216.   if (OFFnum <= 0) {                                                        \
  217.     *(result) = ((curBits & bitMask[bitOffset]) >> (-OFFnum));             \
  218.   } else {                                                                 \
  219.     *(result) = (((curBits & bitMask[bitOffset]) << OFFnum) |              \
  220.              ((*(bitBuffer+1) & (nBitMask[OFFnum])) >> (32-OFFnum)));  \
  221.   }                                                                        \
  222. }
  223. #else
  224. #define show_bitsX(num, thresh, result)                                    \
  225. {                                                                          \
  226.   int OFFnum = (bitOffset - thresh);                                       \
  227.                                                                            \
  228.   /* Check for underflow. */                                               \
  229.   if (bufLength < 2) {                                                     \
  230.     correct_underflow();                                                   \
  231.   }                                                                        \
  232.                                                                            \
  233.   if (OFFnum <= 0) {                                                        \
  234.     *(result) = ((curBits & bitMask[bitOffset]) >> (-OFFnum));             \
  235.   } else {                                                                 \
  236.     *(result) = (((curBits & bitMask[bitOffset]) << OFFnum) |              \
  237.              ((*(bitBuffer+1) & (nBitMask[OFFnum])) >> (32-OFFnum)));  \
  238.   }                                                                        \
  239. }
  240. #endif
  241.  
  242. #define show_bits1(result)  show_bitsX(1,  31, result)
  243. #define show_bits2(result)  show_bitsX(2,  30, result)
  244. #define show_bits3(result)  show_bitsX(3,  29, result)
  245. #define show_bits4(result)  show_bitsX(4,  28, result)
  246. #define show_bits5(result)  show_bitsX(5,  27, result)
  247. #define show_bits6(result)  show_bitsX(6,  26, result)
  248. #define show_bits7(result)  show_bitsX(7,  25, result)
  249. #define show_bits8(result)  show_bitsX(8,  24, result)
  250. #define show_bits9(result)  show_bitsX(9,  23, result)
  251. #define show_bits10(result) show_bitsX(10, 22, result)
  252. #define show_bits11(result) show_bitsX(11, 21, result)
  253. #define show_bits12(result) show_bitsX(12, 20, result)
  254. #define show_bits13(result) show_bitsX(13, 19, result)
  255. #define show_bits14(result) show_bitsX(14, 18, result)
  256. #define show_bits15(result) show_bitsX(15, 17, result)
  257. #define show_bits16(result) show_bitsX(16, 16, result)
  258. #define show_bits17(result) show_bitsX(17, 15, result)
  259. #define show_bits18(result) show_bitsX(18, 14, result)
  260. #define show_bits19(result) show_bitsX(19, 13, result)
  261. #define show_bits20(result) show_bitsX(20, 12, result)
  262. #define show_bits21(result) show_bitsX(21, 11, result)
  263. #define show_bits22(result) show_bitsX(22, 10, result)
  264. #define show_bits23(result) show_bitsX(23,  9, result)
  265. #define show_bits24(result) show_bitsX(24,  8, result)
  266. #define show_bits25(result) show_bitsX(25,  7, result)
  267. #define show_bits26(result) show_bitsX(26,  6, result)
  268. #define show_bits27(result) show_bitsX(27,  5, result)
  269. #define show_bits28(result) show_bitsX(28,  4, result)
  270. #define show_bits29(result) show_bitsX(29,  3, result)
  271. #define show_bits30(result) show_bitsX(30,  2, result)
  272. #define show_bits31(result) show_bitsX(31,  1, result)
  273. #define show_bits32(result) show_bitsX(32,  0, result)
  274.  
  275. #define show_bitsn(num,result) show_bitsX((num),(32-(num)),result)
  276.  
  277. #ifdef NO_SANITY_CHECKS
  278. #define flush_bits(num)                                               \
  279. {                                                                     \
  280.   bitOffset += num;                                                   \
  281.                                                                       \
  282.                                                                           \
  283.   if (bitOffset > 31) {                                               \
  284.     bitBuffer++;                                                      \
  285.     curBits = *bitBuffer;                                             \
  286.     bufLength--;                                                      \
  287.     bitOffset -= 32;                                                  \
  288.   }                                                                   \
  289. }
  290. #else
  291. #define flush_bits(num)                                               \
  292. {                                                                     \
  293.   if (curVidStream == NULL) {                                         \
  294.     /* Deal with no vid stream here. */                               \
  295.   }                                                                   \
  296.                                                                       \
  297.   if (bufLength < 2) {                                                \
  298.     correct_underflow();                                              \
  299.   }                                                                   \
  300.                                                                       \
  301.                                                                           \
  302.   bitOffset += num;                                                   \
  303.                                                                       \
  304.   if (bitOffset > 31) {                                               \
  305.     bitBuffer++;                                                      \
  306.     curBits = *bitBuffer;                                             \
  307.     bufLength--;                                                      \
  308.     bitOffset -= 32;                                                  \
  309.   }                                                                   \
  310. }
  311. #endif
  312.  
  313.